<html><head><meta charset="utf-8"/><title>模块</title></head><body><h1>模块</h1><div class="x-wiki-content x-main-content">
 <p>
  在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里代码就会越来越长，越来越不容易维护。
 </p>
 <p>
  为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。在Node环境中，一个.js文件就称之为一个模块（module）。
 </p>
 <p>
  使用模块有什么好处？
 </p>
 <p>
  最大的好处是大大提高了代码的可维护性。其次，编写代码不必从零开始。当一个模块编写完毕，就可以被其他地方引用。我们在编写程序的时候，也经常引用其他模块，包括Node内置的模块和来自第三方的模块。
 </p>
 <p>
  使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中，因此，我们自己在编写模块时，不必考虑名字会与其他模块冲突。
 </p>
 <p>
  在上一节，我们编写了一个
  <code>
   hello.js
  </code>
  文件，这个
  <code>
   hello.js
  </code>
  文件就是一个模块，模块的名字就是文件名（去掉
  <code>
   .js
  </code>
  后缀），所以
  <code>
   hello.js
  </code>
  文件就是名为
  <code>
   hello
  </code>
  的模块。
 </p>
 <p>
  我们把
  <code>
   hello.js
  </code>
  改造一下，创建一个函数，这样我们就可以在其他地方调用这个函数：
 </p>
 <pre><code>'use strict';

var s = 'Hello';

function greet(name) {
    console.log(s + ', ' + name + '!');
}

module.exports = greet;
</code></pre>
 <p>
  函数
  <code>
   greet()
  </code>
  是我们在
  <code>
   hello
  </code>
  模块中定义的，你可能注意到最后一行是一个奇怪的赋值语句，它的意思是，把函数
  <code>
   greet
  </code>
  作为模块的输出暴露出去，这样其他模块就可以使用
  <code>
   greet
  </code>
  函数了。
 </p>
 <p>
  问题是其他模块怎么使用
  <code>
   hello
  </code>
  模块的这个
  <code>
   greet
  </code>
  函数呢？我们再编写一个
  <code>
   main.js
  </code>
  文件，调用
  <code>
   hello
  </code>
  模块的
  <code>
   greet
  </code>
  函数：
 </p>
 <pre><code>'use strict';

// 引入hello模块:
var greet = require('./hello');

var s = 'Michael';

greet(s); // Hello, Michael!
</code></pre>
 <p>
  注意到引入
  <code>
   hello
  </code>
  模块用Node提供的
  <code>
   require
  </code>
  函数：
 </p>
 <pre><code>var greet = require('./hello');
</code></pre>
 <p>
  引入的模块作为变量保存在
  <code>
   greet
  </code>
  变量中，那
  <code>
   greet
  </code>
  变量到底是什么东西？其实变量
  <code>
   greet
  </code>
  就是在
  <code>
   hello.js
  </code>
  中我们用
  <code>
   module.exports = greet;
  </code>
  输出的
  <code>
   greet
  </code>
  函数。所以，
  <code>
   main.js
  </code>
  就成功地引用了
  <code>
   hello.js
  </code>
  模块中定义的
  <code>
   greet()
  </code>
  函数，接下来就可以直接使用它了。
 </p>
 <p>
  在使用
  <code>
   require()
  </code>
  引入模块的时候，请注意模块的相对路径。因为
  <code>
   main.js
  </code>
  和
  <code>
   hello.js
  </code>
  位于同一个目录，所以我们用了当前目录
  <code>
   .
  </code>
  ：
 </p>
 <pre><code>var greet = require('./hello'); // 不要忘了写相对目录!
</code></pre>
 <p>
  如果只写模块名：
 </p>
 <pre><code>var greet = require('hello');
</code></pre>
 <p>
  则Node会依次在内置模块、全局模块和当前模块下查找
  <code>
   hello.js
  </code>
  ，你很可能会得到一个错误：
 </p>
 <pre><code>module.js
    throw err;
          ^
Error: Cannot find module 'hello'
    at Function.Module._resolveFilename
    at Function.Module._load
    ...
    at Function.Module._load
    at Function.Module.runMain
</code></pre>
 <p>
  遇到这个错误，你要检查：
 </p>
 <ul>
  <li>
   模块名是否写对了；
  </li>
  <li>
   模块文件是否存在；
  </li>
  <li>
   相对路径是否写对了。
  </li>
 </ul>
 <h3>
  CommonJS规范
 </h3>
 <p>
  这种模块加载机制被称为CommonJS规范。在这个规范下，每个
  <code>
   .js
  </code>
  文件都是一个模块，它们内部各自使用的变量名和函数名都互不冲突，例如，
  <code>
   hello.js
  </code>
  和
  <code>
   main.js
  </code>
  都申明了全局变量
  <code>
   var s = 'xxx'
  </code>
  ，但互不影响。
 </p>
 <p>
  一个模块想要对外暴露变量（函数也是变量），可以用
  <code>
   module.exports = variable;
  </code>
  ，一个模块要引用其他模块暴露的变量，用
  <code>
   var ref = require('module_name');
  </code>
  就拿到了引用模块的变量。
 </p>
 <h3>
  结论
 </h3>
 <p>
  要在模块中对外输出变量，用：
 </p>
 <pre><code>module.exports = variable;
</code></pre>
 <p>
  输出的变量可以是任意对象、函数、数组等等。
 </p>
 <p>
  要引入其他模块输出的对象，用：
 </p>
 <pre><code>var foo = require('other_module');
</code></pre>
 <p>
  引入的对象具体是什么，取决于引入模块输出的对象。
 </p>
 <h3>
  深入了解模块原理
 </h3>
 <p>
  如果你想详细地了解CommonJS的模块实现原理，请继续往下阅读。如果不想了解，请直接跳到最后做练习。
 </p>
 <p>
  当我们编写JavaScript代码时，我们可以申明全局变量：
 </p>
 <pre><code>var s = 'global';
</code></pre>
 <p>
  在浏览器中，大量使用全局变量可不好。如果你在
  <code>
   a.js
  </code>
  中使用了全局变量
  <code>
   s
  </code>
  ，那么，在
  <code>
   b.js
  </code>
  中也使用全局变量
  <code>
   s
  </code>
  ，将造成冲突，
  <code>
   b.js
  </code>
  中对
  <code>
   s
  </code>
  赋值会改变
  <code>
   a.js
  </code>
  的运行逻辑。
 </p>
 <p>
  也就是说，JavaScript语言本身并没有一种模块机制来保证不同模块可以使用相同的变量名。
 </p>
 <p>
  那Node.js是如何实现这一点的？
 </p>
 <p>
  其实要实现“模块”这个功能，并不需要语法层面的支持。Node.js也并不会增加任何JavaScript语法。实现“模块”功能的奥妙就在于JavaScript是一种函数式编程语言，它支持闭包。如果我们把一段JavaScript代码用一个函数包装起来，这段代码的所有“全局”变量就变成了函数内部的局部变量。
 </p>
 <p>
  请注意我们编写的
  <code>
   hello.js
  </code>
  代码是这样的：
 </p>
 <pre><code>var s = 'Hello';
var name = 'world';

console.log(s + ' ' + name + '!');
</code></pre>
 <p>
  Node.js加载了
  <code>
   hello.js
  </code>
  后，它可以把代码包装一下，变成这样执行：
 </p>
 <pre><code>(function () {
    // 读取的hello.js代码:
    var s = 'Hello';
    var name = 'world';

    console.log(s + ' ' + name + '!');
    // hello.js代码结束
})();
</code></pre>
 <p>
  这样一来，原来的全局变量
  <code>
   s
  </code>
  现在变成了匿名函数内部的局部变量。如果Node.js继续加载其他模块，这些模块中定义的“全局”变量
  <code>
   s
  </code>
  也互不干扰。
 </p>
 <p>
  所以，Node利用JavaScript的函数式编程的特性，轻而易举地实现了模块的隔离。
 </p>
 <p>
  但是，模块的输出
  <code>
   module.exports
  </code>
  怎么实现？
 </p>
 <p>
  这个也很容易实现，Node可以先准备一个对象
  <code>
   module
  </code>
  ：
 </p>
 <pre><code>// 准备module对象:
var module = {
    id: 'hello',
    exports: {}
};
var load = function (module) {
    // 读取的hello.js代码:
    function greet(name) {
        console.log('Hello, ' + name + '!');
    }
    
    module.exports = greet;
    // hello.js代码结束
    return module.exports;
};
var exported = load(module);
// 保存module:
save(module, exported);
</code></pre>
 <p>
  可见，变量
  <code>
   module
  </code>
  是Node在加载js文件前准备的一个变量，并将其传入加载函数，我们在
  <code>
   hello.js
  </code>
  中可以直接使用变量
  <code>
   module
  </code>
  原因就在于它实际上是函数的一个参数：
 </p>
 <pre><code>module.exports = greet;
</code></pre>
 <p>
  通过把参数
  <code>
   module
  </code>
  传递给
  <code>
   load()
  </code>
  函数，
  <code>
   hello.js
  </code>
  就顺利地把一个变量传递给了Node执行环境，Node会把
  <code>
   module
  </code>
  变量保存到某个地方。
 </p>
 <p>
  由于Node保存了所有导入的
  <code>
   module
  </code>
  ，当我们用
  <code>
   require()
  </code>
  获取module时，Node找到对应的
  <code>
   module
  </code>
  ，把这个
  <code>
   module
  </code>
  的
  <code>
   exports
  </code>
  变量返回，这样，另一个模块就顺利拿到了模块的输出：
 </p>
 <pre><code>var greet = require('./hello');
</code></pre>
 <p>
  以上是Node实现JavaScript模块的一个简单的原理介绍。
 </p>
 <h3>
  module.exports vs exports
 </h3>
 <p>
  很多时候，你会看到，在Node环境中，有两种方法可以在一个模块中输出变量：
 </p>
 <p>
  方法一：对module.exports赋值：
 </p>
 <pre><code>// hello.js

function hello() {
    console.log('Hello, world!');
}

function greet(name) {
    console.log('Hello, ' + name + '!');
}

module.exports = {
    hello: hello,
    greet: greet
};
</code></pre>
 <p>
  方法二：直接使用exports：
 </p>
 <pre><code>// hello.js

function hello() {
    console.log('Hello, world!');
}

function greet(name) {
    console.log('Hello, ' + name + '!');
}

function hello() {
    console.log('Hello, world!');
}

exports.hello = hello;
exports.greet = greet;
</code></pre>
 <p>
  但是你不可以直接对
  <code>
   exports
  </code>
  赋值：
 </p>
 <pre><code>// 代码可以执行，但是模块并没有输出任何变量:
exports = {
    hello: hello,
    greet: greet
};
</code></pre>
 <p>
  如果你对上面的写法感到十分困惑，不要着急，我们来分析Node的加载机制：
 </p>
 <p>
  首先，Node会把整个待加载的
  <code>
   hello.js
  </code>
  文件放入一个包装函数
  <code>
   load
  </code>
  中执行。在执行这个
  <code>
   load()
  </code>
  函数前，Node准备好了module变量：
 </p>
 <pre><code>var module = {
    id: 'hello',
    exports: {}
};
</code></pre>
 <p>
  <code>
   load()
  </code>
  函数最终返回
  <code>
   module.exports
  </code>
  ：
 </p>
 <pre><code>var load = function (exports, module) {
    // hello.js的文件内容
    ...
    // load函数返回:
    return module.exports;
};

var exported = load(module.exports, module);
</code></pre>
 <p>
  也就是说，默认情况下，Node准备的
  <code>
   exports
  </code>
  变量和
  <code>
   module.exports
  </code>
  变量实际上是同一个变量，并且初始化为空对象
  <code>
   {}
  </code>
  ，于是，我们可以写：
 </p>
 <pre><code>exports.foo = function () { return 'foo'; };
exports.bar = function () { return 'bar'; };
</code></pre>
 <p>
  也可以写：
 </p>
 <pre><code>module.exports.foo = function () { return 'foo'; };
module.exports.bar = function () { return 'bar'; };
</code></pre>
 <p>
  换句话说，Node默认给你准备了一个空对象
  <code>
   {}
  </code>
  ，这样你可以直接往里面加东西。
 </p>
 <p>
  但是，如果我们要输出的是一个函数或数组，那么，只能给
  <code>
   module.exports
  </code>
  赋值：
 </p>
 <pre><code>module.exports = function () { return 'foo'; };
</code></pre>
 <p>
  给
  <code>
   exports
  </code>
  赋值是无效的，因为赋值后，
  <code>
   module.exports
  </code>
  仍然是空对象
  <code>
   {}
  </code>
  。
 </p>
 <h3>
  结论
 </h3>
 <p>
  如果要输出一个键值对象
  <code>
   {}
  </code>
  ，可以利用
  <code>
   exports
  </code>
  这个已存在的空对象
  <code>
   {}
  </code>
  ，并继续在上面添加新的键值；
 </p>
 <p>
  如果要输出一个函数或数组，必须直接对
  <code>
   module.exports
  </code>
  对象赋值。
 </p>
 <p>
  所以我们可以得出结论：直接对
  <code>
   module.exports
  </code>
  赋值，可以应对任何情况：
 </p>
 <pre><code>module.exports = {
    foo: function () { return 'foo'; }
};
</code></pre>
 <p>
  或者：
 </p>
 <pre><code>module.exports = function () { return 'foo'; };
</code></pre>
 <p>
  最终，我们
  <em>
   强烈建议
  </em>
  使用
  <code>
   module.exports = xxx
  </code>
  的方式来输出模块变量，这样，你只需要记忆一种方法。
 </p>
 <h3>
  练习
 </h3>
 <p>
  编写
  <code>
   hello.js
  </code>
  ，输出一个或多个函数；
 </p>
 <p>
  编写
  <code>
   main.js
  </code>
  ，引入
  <code>
   hello
  </code>
  模块，调用其函数。
 </p>
 <h3>
  参考源码
 </h3>
 <p>
  <a href="https://github.com/michaelliao/learn-javascript/tree/master/samples/node/module">
   module
  </a>
 </p>
</div>
</body></html>